export const StringData = [
    {
        key: 1,
        name: "camelCase",
        remark: "转换字符串string为驼峰写法",
        use: "_.camelCase([string=''])",
        description: `
            转换字符串string为驼峰写法。
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回驼峰写法的字符串。",
        case: `
_.camelCase('Foo Bar');
// => 'fooBar'

_.camelCase('--foo-bar--');
// => 'fooBar'

_.camelCase('__FOO_BAR__');
// => 'fooBar'
        `,
    },
    {
        key: 2,
        name: "capitalize",
        remark: "转换字符串string首字母为大写，剩下为小写",
        use: ".capitalize([string=''])",
        description: `
            转换字符串string首字母为大写，剩下为小写。
        `,
        argument: `
[string=''] (string): 要大写开头的字符串。
        `,
        return: "(string): 返回大写开头的字符串。",
        case: `
_.capitalize('FRED');
// => 'Fred'
        `,
    },
    {
        key: 3,
        name: "deburr",
        remark: "转换字符串为基本的拉丁字母",
        use: "_.deburr([string=''])",
        description: `
            转换字符串string中拉丁语-1补充字母 和拉丁语扩展字母-A 为基本的拉丁字母，并且去除组合变音标记。
        `,
        argument: `
[string=''] (string): 要处理的字符串。
        `,
        return: "(string): 返回处理后的字符串。",
        case: `
_.deburr('déjà vu');
// => 'deja vu'
        `,
    },
    {
        key: 4,
        name: "endsWith",
        remark: "从指定位置开始检索是否以指定字符串结尾",
        use: "_.endsWith([string=''], [target], [position=string.length])",
        description: `
            检查字符串string是否以给定的target字符串结尾。
        `,
        argument: `
1.[string=''] (string): 要检索的字符串。
2.[target] (string): 要检索字符。
3.[position=string.length] (number): 检索的位置。
        `,
        return: "(boolean): 如果字符串string以target字符串结尾，那么返回 true，否则返回 false。",
        case: `
_.endsWith('abc', 'c');
// => true

_.endsWith('abc', 'b');
// => false

_.endsWith('abc', 'b', 2);
// => true
        `,
    },
    {
        key: 5,
        name: "escape",
        remark: "转义特殊字符",
        use: "_.escape([string=''])",
        description: `
转义string中的 "&", "<", ">", '"', "'", 和 ES6指定 字符为HTML实体字符。注意: 不会转义其他字符。如果需要，可以使用第三方库，例如he。
虽然 ">" 是对称转义的，字符如 ">" 和 "/" 没有特殊的意义，所以不需要在 HTML 转义。 除非它们是标签的一部分，或者是不带引号的属性值。 查看Mathias Bynens's article 的文章 (under "semi-related fun fact") 了解详情 。
在 IE< 9 中转义引号，因为会中断属性值或 HTML 注释，查看HTML5 Security Cheatsheet 的#59,#102,#108, 和#133, 以及#133 了解详情。
当解析 HTML 时，总应该在属性值上使用引号 以减少 XSS 的可能性。
        `,
        argument: `
[string=''] (string): 要转义的字符串。
        `,
        return: "(string): 返回转义后的字符串。",
        case: `
_.escape('fred, barney, & pebbles');
// => 'fred, barney, & pebbles'
        `,
    },
    {
        key: 6,
        name: "escapeRegExp",
        remark: "转义 RegExp 字符串中特殊的字符",
        use: "_.escapeRegExp([string=''])",
        description: `
            转义 RegExp 字符串中特殊的字符 "^", "$", "", ".", "*", "+", "?", "(", ")", "[", "]", ", ", 和 "|" in .
        `,
        argument: `
[string=''] (string): 要转义的字符串。
        `,
        return: "(string): 返回转义后的字符串。",
        case: `
_.escapeRegExp('[lodash](https://lodash.com/)');
// => '\[lodash\]\(https://lodash\.com/\)'
        `,
    },
    {
        key: 7,
        name: "kebabCase",
        remark: "转换字符串string为xxx-xxx形式字符串",
        use: "_.kebabCase([string=''])",
        description: `
            转换字符串string为kebab case.
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回转换后的字符串。",
        case: `
_.kebabCase('Foo Bar');
// => 'foo-bar'

_.kebabCase('fooBar');
// => 'foo-bar'

_.kebabCase('__FOO_BAR__');
// => 'foo-bar'
        `,
    },
    {
        key: 8,
        name: "lowerCase",
        remark: "转换字符串string以空格分开单词，并转换为小写",
        use: "_.lowerCase([string=''])",
        description: `
            转换字符串string以空格分开单词，并转换为小写。
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回转换后的字符串。",
        case: `
_.lowerCase('--Foo-Bar--');
// => 'foo bar'

_.lowerCase('fooBar');
// => 'foo bar'

_.lowerCase('__FOO_BAR__');
// => 'foo bar'
        `,
    },
    {
        key: 9,
        name: "lowerFirst",
        remark: "转换字符串string的首字母为小写",
        use: "_.lowerFirst([string=''])",
        description: `
            转换字符串string的首字母为小写。
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回转换后的字符串。",
        case: `
_.lowerFirst('Fred');
// => 'fred'

_.lowerFirst('FRED');
// => 'fRED'
        `,
    },
    {
        key: 10,
        name: "pad",
        remark: "为指定字符串左右添加指定字符（串）",
        use: "_.pad([string=''], [length=0], [chars=' '])",
        description: `
            如果string字符串长度小于 length 则从左侧和右侧填充字符。 如果没法平均分配，则截断超出的长度。
        `,
        argument: `
1.[string=''] (string): 要填充的字符串。
2.[length=0] (number): 填充的长度。
3.[chars=' '] (string): 填充字符。
        `,
        return: "(string): 返回填充后的字符串。",
        case: `
_.pad('abc', 8);
// => '  abc   '

_.pad('abc', 8, '_-');
// => '_-abc_-_'

_.pad('abc', 3);
// => 'abc'
        `,
    },
    {
        key: 11,
        name: "padEnd",
        remark: "字符串右侧填充指定字符（串）",
        use: "_.padEnd([string=''], [length=0], [chars=' '])",
        description: `
            如果string字符串长度小于 length 则在右侧填充字符。 如果超出length长度则截断超出的部分。
        `,
        argument: `
1.[string=''] (string): 要填充的字符串。
2.[length=0] (number): 填充的长度。
3.[chars=' '] (string): 填充字符。
        `,
        return: "(string): 返回填充后的字符串。",
        case: `
_.padEnd('abc', 6);
// => 'abc   '

_.padEnd('abc', 6, '_-');
// => 'abc_-_'

_.padEnd('abc', 3);
// => 'abc'
        `,
    },
    {
        key: 12,
        name: "parseInt",
        remark: "字符串转数字",
        use: "_.parseInt(string, [radix=10])",
        description: `
            转换string字符串为指定基数的整数。 如果基数是 undefined 或者 0，则radix基数默认是10，如果string字符串是16进制，则radix基数为 16。注意: 这个方法与ES5 implementation 的 parseInt是一样的。
        `,
        argument: `
1.string (string): 要转换的字符串。
2.[radix=10] (number):转换基数。
        `,
        return: "(number): 返回转换后的整数。",
        case: `
_.parseInt('08');
// => 8

_.map(['6', '08', '10'], _.parseInt);
// => [6, 8, 10]
        `,
    },
    {
        key: 13,
        name: "repeat",
        remark: "重复 N 次给定字符串。",
        use: "_.repeat([string=''], [n=1])",
        description: `
            重复 N 次给定字符串。
        `,
        argument: `
1.[string=''] (string): 要重复的字符串。
2.[n=1] (number): 重复的次数。
        `,
        return: "(string): 返回重复的字符串。",
        case: `
_.repeat('*', 3);
// => '***'

_.repeat('abc', 2);
// => 'abcabc'

_.repeat('abc', 0);
// => ''
        `,
    },
    {
        key: 14,
        name: "replace",
        remark: "替换指定字符串",
        use: "_.replace([string=''], pattern, replacement)",
        description: `
            替换string字符串中匹配的pattern为给定的replacement 。注意: 这个方法基于String#replace.
        `,
        argument: `
1.[string=''] (string): 待替换的字符串。
2.pattern (RegExp|string): 要匹配的内容。
3.replacement (Function|string): 替换的内容。
        `,
        return: "string): 返回替换后的字符串",
        case: `
_.replace('Hi Fred', 'Fred', 'Barney');
// => 'Hi Barney'
        `,
    },
    {
        key: 15,
        name: "snakeCase",
        remark: "转换字符串单词中间以_分隔",
        use: "_.snakeCase([string=''])",
        description: `
            转换字符串string为snake case.
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回转换后的字符串。",
        case: `
_.snakeCase('Foo Bar');
// => 'foo_bar'

_.snakeCase('fooBar');
// => 'foo_bar'

_.snakeCase('--FOO-BAR--');
// => 'foo_bar'
        `,
    },
    {
        key: 16,
        name: "split",
        remark: "按分隔符对字符串进行分割",
        use: "_.split([string=''], separator, [limit])",
        description: `
            根据separator 拆分字符串string。注意: 这个方法基于String#split.
        `,
        argument: `
1.[string=''] (string): 要拆分的字符串。
2.separator (RegExp|string): 拆分的分隔符。
3.[limit] (number): 限制结果的数量。
        `,
        return: "(Array): 返回拆分部分的字符串的数组。",
        case: `
_.split('a-b-c', '-', 2);
// => ['a', 'b']
        `,
    },
    {
        key: 17,
        name: "startCase",
        remark: "转换字符串以空格分隔，每个单词首字母大写",
        use: "_.startCase([string=''])",
        description: `
            转换 string 字符串为start case.
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回转换后的字符串。",
        case: `
_.startCase('--foo-bar--');
// => 'Foo Bar'

_.startCase('fooBar');
// => 'Foo Bar'

_.startCase('__FOO_BAR__');
// => 'FOO BAR'
        `,
    },
    {
        key: 18,
        name: "startsWith",
        remark: "从指定位置开始，判断字符串是否以指定字符串开头",
        use: "_.startsWith([string=''], [target], [position=0])",
        description: `
            检查字符串string是否以 target 开头。
        `,
        argument: `
1.[string=''] (string): 要检索的字符串。
2.[target] (string): 要检查的字符串。
3.[position=0] (number): 检索的位置。
        `,
        return: "(boolean): 如果string以 target，那么返回true，否则返回 false 。",
        case: `
(boolean): 如果string以 target，那么返回true，否则返回 false 。
        `,
    },
    {
        key: 19,
        name: "template",
        remark: "创建编译目标函数，可以插入数据在模板中",
        use: "_.template([string=''], [options=])",
        description: `
            创建一个预编译模板方法，可以插入数据到模板中 "interpolate" 分隔符相应的位置。 HTML会在 "escape" 分隔符中转换为相应实体。 在 "evaluate" 分隔符中允许执行JavaScript代码。 在模板中可以自由访问变量。 如果设置了选项对象，则会优先覆盖_.templateSettings 的值。
        注意: 在开发过程中，构建_.template可以使用sourceURLs【http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl】， 便于调试。
了解更多预编译模板的信息查看lodash的自定义构建文档【https://lodash.com/custom-builds】。
了解更多 Chrome 沙箱扩展的信息查看Chrome的扩展文档【https://developer.chrome.com/extensions/sandboxingEval】。
            `,
        argument: `
1.[string=''] (string): 模板字符串.
2.[options=] (Object): 选项对象.
3.[options.escape=_.templateSettings.escape] (RegExp): "escape" 分隔符.
4.[options.evaluate=_.templateSettings.evaluate] (RegExp): "evaluate" 分隔符.
5.[options.imports=_.templateSettings.imports] (Object): 导入对象到模板中作为自由变量。
6.[options.interpolate=_.templateSettings.interpolate] (RegExp): "interpolate" 分隔符。
7.[options.sourceURL='lodash.templateSources[n]'] (string): 模板编译的来源URL。
8.[options.variable='obj'] (string): 数据对象的变量名。
        `,
        return: "(Function): 返回编译模板函数",
        case: `
// 使用 "interpolate" 分隔符创建编译模板
var compiled = _.template('hello <%= user %>!');
compiled({ 'user': 'fred' });
// => 'hello fred!'
 
// 使用 HTML "escape" 转义数据的值
var compiled = _.template('<b><%- value %></b>');
compiled({ 'value': '<script>' });
// => '<b><script></b>'
 
// 使用 "evaluate" 分隔符执行 JavaScript 和 生成HTML代码
var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
compiled({ 'users': ['fred', 'barney'] });
// => '<li>fred</li><li>barney</li>'
 
// 在 "evaluate" 分隔符中使用内部的 print 函数
var compiled = _.template('<% print("hello " + user); %>!');
compiled({ 'user': 'barney' });
// => 'hello barney!'
 
// 使用 ES 分隔符代替默认的 "interpolate" 分隔符
var compiled = _.template('hello $/{user}!');
compiled({ 'user': 'pebbles' });
// => 'hello pebbles!'
 
// 使用自定义的模板分隔符
_.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
var compiled = _.template('hello {{ user }}!');
compiled({ 'user': 'mustache' });
// => 'hello mustache!'
 
// 使用反斜杠符号作为纯文本处理
var compiled = _.template('<%= "\\<%- value %\\>" %>');
compiled({ 'value': 'ignored' });
// => '<%- value %>'
 
// 使用 imports 选项导入 jq 作为 jQuery 的别名
var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
compiled({ 'users': ['fred', 'barney'] });
// => '<li>fred</li><li>barney</li>'
 
// 使用 sourceURL 选项指定模板的来源URL
var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
compiled(data);
// => 在开发工具的 Sources 选项卡 或 Resources 面板中找到 "greeting.jst"
 
// 使用 variable 选项确保在编译模板中不声明变量
var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
compiled.source;
// => function(data) {
//   var __t, __p = '';
//   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
//   return __p;
// }
 
// 使用 source 特性内联编译模板
// 便以查看行号、错误信息、堆栈
fs.writeFileSync(path.join(cwd, 'jst.js'), '\
  var JST = {\
    "main": ' + _.template(mainText).source + '\
  };\
');
        `,
    },
    {
        key: 20,
        name: "toLower",
        remark: "字符串转小写",
        use: "_.toLower([string=''])",
        description: `
            转换整个string字符串的字符为小写，类似String#toLowerCase。
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回小写的字符串。",
        case: `
_.toLower('--Foo-Bar--');
// => '--foo-bar--'

_.toLower('fooBar');
// => 'foobar'

_.toLower('__FOO_BAR__');
// => '__foo_bar__'
        `,
    },
    {
        key: 21,
        name: "toUpper",
        remark: "字符串转大写",
        use: "_.toUpper([string=''])",
        description: `
            转换整个string字符串的字符为大写，类似String#toUpperCase.
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回大写的字符串。",
        case: `
_.toUpper('--foo-bar--');
// => '--FOO-BAR--'

_.toUpper('fooBar');
// => 'FOOBAR'

_.toUpper('__foo_bar__');
// => '__FOO_BAR__'
        `,
    },
    {
        key: 22,
        name: "trim",
        remark: "移除空字符串或者是指定字符串",
        use: "_.trim([string=''], [chars=whitespace])",
        description: `
            从string字符串中移除前面和后面的 空格 或 指定的字符。
        `,
        argument: `
1.[string=''] (string): 要处理的字符串。
2.[chars=whitespace] (string): 要移除的字符。
        `,
        return: "(string): 返回处理后的字符串。",
        case: `
_.trim('  abc  ');
// => 'abc'

_.trim('-_-abc-_-', '_-');
// => 'abc'

_.map(['  foo  ', '  bar  '], _.trim);
// => ['foo', 'bar']
        `,
    },
    {
        key: 23,
        name: "trimEnd",
        remark: "移除字符串后的空格或者指定字符串",
        use: "_.trimEnd([string=''], [chars=whitespace])",
        description: `
            从string字符串中移除后面的 空格 或 指定的字符。
        `,
        argument: `
1.[string=''] (string): 要处理的字符串。
2.[chars=whitespace] (string): 要移除的字符。
        `,
        return: "(string): 返回处理后的字符串。",
        case: `
_.trimEnd('  abc  ');
// => '  abc'

_.trimEnd('-_-abc-_-', '_-');
// => '-_-abc'
        `,
    },
    {
        key: 24,
        name: "trimStart",
        remark: "移除字符串前面的空格或者指定字符串",
        use: "_.trimStart([string=''], [chars=whitespace])",
        description: `
            从string字符串中移除前面的 空格 或 指定的字符。
        `,
        argument: `
1.[string=''] (string): 要处理的字符串。
2.[chars=whitespace] (string): 要移除的字符。
        `,
        return: "(string): 返回处理后的字符串。",
        case: `
_.trimStart('  abc  ');
// => 'abc  '

_.trimStart('-_-abc-_-', '_-');
// => 'abc-_-'
        `,
    },
    {
        key: 25,
        name: "truncate",
        remark: "截断string字符串后用指定字符代替",
        use: "_.truncate([string=''], [options=])",
        description: `
            截断string字符串，如果字符串超出了限定的最大值。 被截断的字符串后面会以 omission 代替，omission 默认是 "..."。
        `,
        argument: `
1.[string=''] (string): 要截断的字符串。
2.[options=] (Object): 选项对象。
3.[options.length=30] (number): 允许的最大长度。
4.[options.omission='...'] (string): 超出后的代替字符。
5.[options.separator] (RegExp|string): 截断点。
        `,
        return: "(string): Returns the truncated string.",
        case: `
_.truncate('hi-diddly-ho there, neighborino');
// => 'hi-diddly-ho there, neighbo...'

_.truncate('hi-diddly-ho there, neighborino', {
  'length': 24,
  'separator': ' '
});
// => 'hi-diddly-ho there,...'

_.truncate('hi-diddly-ho there, neighborino', {
  'length': 24,
  'separator': /,? +/
});
// => 'hi-diddly-ho there...'

_.truncate('hi-diddly-ho there, neighborino', {
  'omission': ' [...]'
});
// => 'hi-diddly-ho there, neig [...]'
        `,
    },
    {
        key: 26,
        name: "unescape",
        remark: "_.escape的反向版，转换string字符串为HTML",
        use: "_.unescape([string=''])",
        description: `
_.escape的反向版。 这个方法转换string字符串中的 HTML 实体 &amp;, &lt;, &gt;, &quot;, &#39;, 和 &#96; 为对应的字符。
注意: 不会转换其他的 HTML 实体，需要转换可以使用类似 he 的第三方库。
注意: 不会转换其他的 HTML 实体，需要转换可以使用第三方库，类似he。
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回转换后的字符串。",
        case: `
_.unescape('fred, barney, & pebbles');
// => 'fred, barney, & pebbles'
        `,
    },
    {
        key: 27,
        name: "upperCase",
        remark: "转换字符串为大写单词，中间以空格分隔",
        use: "_.upperCase([string=''])",
        description: `
            转换字符串string为 空格 分隔的大写单词。
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回大写单词。",
        case: `
_.upperCase('--foo-bar');
// => 'FOO BAR'

_.upperCase('fooBar');
// => 'FOO BAR'

_.upperCase('__foo_bar__');
// => 'FOO BAR'
        `,
    },
    {
        key: 28,
        name: "upperFirst",
        remark: "转换字符串string的首字母为大写",
        use: "_.upperFirst([string=''])",
        description: `
            转换字符串string的首字母为大写
        `,
        argument: `
[string=''] (string): 要转换的字符串。
        `,
        return: "(string): 返回转换后的字符串。",
        case: `
_.upperFirst('fred');
// => 'Fred'

_.upperFirst('FRED');
// => 'FRED'
        `,
    },
    {
        key: 29,
        name: "words",
        remark: "拆分字符串中的词为数组，可以自定义匹配模式",
        use: "_.words([string=''], [pattern])",
        description: `
            拆分字符串string中的词为数组 。
        `,
        argument: `
1.[string=''] (string): 要拆分的字符串。
2.[pattern] (RegExp|string): 匹配模式。
        `,
        return: "(Array): 返回拆分string后的数组。",
        case: `
_.words('fred, barney, & pebbles');
// => ['fred', 'barney', 'pebbles']

_.words('fred, barney, & pebbles', /[^, ]+/g);
// => ['fred', 'barney', '&', 'pebbles']
        `,
    },
];
